home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 526-550 / disk_540 / browser / browserii_src.lzh / Run.c < prev    next >
C/C++ Source or Header  |  1991-06-30  |  7KB  |  298 lines
  1. /*
  2.  *    Run.c - Copyright © 1991 by S.R. & P.C.
  3.  *
  4.  *    Created:    30 Mar 1991  17:13:14
  5.  *    Modified:    30 Jun 1991  11:11:35
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. #include "Global.h"
  11. #include "proto/Run.h"
  12. #include "proto/Menus.h"
  13. #include "proto/Windows.h"
  14. #include "proto/Process.h"
  15.  
  16.  
  17. /* don't track resources here because workbench's can be released by another process */
  18.  
  19. #ifdef TRACKER
  20. #undef AllocMem
  21. #undef FreeMem
  22. #undef CopyStr
  23. #undef FreeStr
  24. #undef ParentDir
  25. #undef CreateDir
  26. #undef Lock
  27. #undef DupLock
  28. #undef UnLock
  29. #endif
  30.  
  31. #define MAX_CLIARGS_LEN 250
  32.  
  33. extern struct Config Config;
  34. extern struct ParMConfig ParMConfig;
  35. extern struct MinList WindowList;
  36. extern struct BrowserWindow *CurrentWin;
  37. extern struct Menu Menu1;
  38. extern char *ReqTitle;
  39. extern BPTR BrowserDir;
  40. extern short SelectNum;
  41.  
  42.  
  43. static struct Extended_WBStartup *BuildWBStartup(struct ScrollEntry *Run, char *Cmd, long Stack)
  44. {
  45.     struct Extended_WBStartup *EWBS;
  46.     struct BrowserWindow *Win;
  47.     struct ScrollEntry *S;
  48.     short NumArg, i, arg=1;
  49.  
  50.     if (!(EWBS = AllocMem(sizeof(struct Extended_WBStartup), MEMF_PUBLIC|MEMF_CLEAR)))
  51.         return NULL;
  52.     NumArg = SelectNum;
  53.     if (!Run)    /* Menu selection then, so one arg more for the tool from menu */
  54.         NumArg++;
  55.     /* Allocate array for NumArg+1 args. Only NumArg may be needed */
  56.     if (!(EWBS->ArgArray = AllocMem((NumArg+1)*sizeof(struct WBArg), MEMF_PUBLIC|MEMF_CLEAR))) {
  57.         WBFree(EWBS);
  58.         return NULL;
  59.     }
  60.     EWBS->ArrayLength = NumArg + 1;
  61.     EWBS->WBStartup.sm_NumArgs = NumArg;
  62.     EWBS->WBStartup.sm_ArgList = &EWBS->ArgArray[1];
  63.  
  64.     if (!Run && !MakeWBArg(&ParMConfig, EWBS->WBStartup.sm_ArgList, Cmd)) {
  65.         WBFree(EWBS);
  66.         return NULL;
  67.     }
  68.     Win = (struct BrowserWindow *)WindowList.mlh_Head;
  69.     while(Win->bw_Node.mln_Succ) {
  70.         if (Win->bw_SelectNum > 0) {
  71.             for( i=0 ; i < Win->bw_ShownEntries ; i++ ) {
  72.                 S = Win->bw_EntryArray[i];
  73.                 if (S->se_State & STATE_SELECTED) {
  74.                     if (S == Run) {
  75.                         EWBS->WBStartup.sm_ArgList[0].wa_Name = CopyStr(Cmd);
  76.                         EWBS->WBStartup.sm_ArgList[0].wa_Lock = DupLock(Win->bw_DirLock);
  77.                     }
  78.                     else {
  79.                         EWBS->WBStartup.sm_ArgList[arg].wa_Name = CopyStr(S->se_FileInfo.fi_Name);
  80.                         EWBS->WBStartup.sm_ArgList[arg].wa_Lock = DupLock(Win->bw_DirLock);
  81.                         arg++;
  82.                     }
  83.                 }
  84.             }
  85.         }
  86.         Win = (struct BrowserWindow *) Win->bw_Node.mln_Succ;
  87.     }
  88.     if (!GetTool(&ParMConfig, EWBS, Stack)) {
  89.         WBFree(EWBS);
  90.         return NULL;
  91.     }
  92.     return EWBS;
  93. }
  94.  
  95.  
  96. static BOOL BuildCLIArgs(char *Args, BPTR CurDir, BPTR CurRootDir, struct ScrollEntry *Current)
  97. {
  98.     struct BrowserWindow *Win;
  99.     struct ScrollEntry *S;
  100.     char *Dir, *sp1, *sp2;
  101.     short len = 0, dirlen, i;
  102.     char tmpbuf[256];
  103.  
  104.     sp1 = Args;
  105.     *sp1 = '\0';
  106.     Win = (struct BrowserWindow *)WindowList.mlh_Head;
  107.     while (Win->bw_Node.mln_Succ) {
  108.         if (Win->bw_SelectNum > 0) {
  109.             if (Win->bw_Type == BW_MAIN || CurDir && !CompareLock(CurDir, Win->bw_DirLock)) {
  110.                 Dir = NULL;
  111.                 dirlen = 0;
  112.             }
  113.             else {
  114.                 strcpy(tmpbuf, (char *)Win->bw_Window->Title);
  115.                 Dir = tmpbuf;
  116.                 if (CurRootDir && !CompareLock(CurRootDir, Win->bw_RootLock))
  117.                     while(*Dir && *Dir != ':') Dir++;    /* Remove volume name from dir */
  118.                 sp2 = Dir;
  119.                 while(*sp2++);
  120.                 *sp2-- = '\0';
  121.                 if (*(sp2-1) != ':')
  122.                     *sp2 = '/';
  123.                 dirlen = strlen(Dir);
  124.             }
  125.             for( i=0 ; i < Win->bw_ShownEntries ; i++ ) {
  126.                 S = Win->bw_EntryArray[i];
  127.                 if ((S->se_State & STATE_SELECTED) && (S != Current)) {
  128.                     if (len+dirlen+strlen(sp2 = S->se_FileInfo.fi_Name)+3 > 250) {
  129.                         SimpleRequest(ReqTitle, "Command line too long.");
  130.                         return FALSE;
  131.                     }
  132.                     len += SPrintf(sp1, " \"%s%s\"", Dir, S->se_FileInfo.fi_Name);
  133.                     sp1 = Args + len;
  134.                 }
  135.             }
  136.         }
  137.         Win = (struct BrowserWindow *) Win->bw_Node.mln_Succ;
  138.     }
  139.     return TRUE;
  140. }
  141.  
  142.  
  143. static BOOL AddArgs(char *Dest, char *Args)
  144. {
  145.     char *s, tmpbuf[256];
  146.  
  147.     if (strlen(Dest)+strlen(Args) > 252) {
  148.         SimpleRequest(ReqTitle, "Command line too long.");
  149.         return FALSE;
  150.     }
  151.     tmpbuf[0] = '\0';
  152.     s = Dest;
  153.     while(*s) {
  154.         if (*s == '[' && *(s+1) == ']') {
  155.             strcpy(tmpbuf, s+2);
  156.             break;
  157.         }
  158.         s++;
  159.     }
  160.     strcpy(s, Args);
  161.     strcpy(&Dest[strlen(Dest)], tmpbuf);    /* strcat() */
  162.     return TRUE;
  163. }
  164.  
  165.  
  166. /* Result: Tell caller if extended select can be done */
  167.  
  168. BOOL DoExtMenu(USHORT MenuNum)
  169. {
  170.     struct Extended_MenuItem *Item;
  171.     struct Extended_WBStartup *EWBS;
  172.     struct RunInfo Command;
  173.     BPTR DirLock=0L, RootLock=0L;
  174.     char Args[256], Buffer[256];
  175.  
  176.     Item = (struct Extended_MenuItem *)ItemAddress(&Menu1, MenuNum);
  177.     Command = Item->emi_RunInfo;
  178.     switch (Item->emi_Mode) {
  179.     case TOK_CFG:    /* new cfg */
  180.         strcpy(ParMConfig.CurCfg, Command.ri_Cmd);
  181.         UpdateMenus();
  182.         return FALSE;    /* Tell caller not to execute next menu selection */
  183.     case TOK_WB:
  184.         SetWaitPointer(TRUE);
  185.         if (EWBS = BuildWBStartup(NULL, Command.ri_Cmd, Command.ri_Stack))
  186.             ASyncWBRun(&ParMConfig, EWBS, Command.ri_Pri);
  187.         SetWaitPointer(FALSE);
  188.         break;
  189.     default:
  190.         if (CurrentWin->bw_Type != BW_MAIN) {
  191.             CurrentDir(DirLock = CurrentWin->bw_DirLock);
  192.             RootLock = CurrentWin->bw_RootLock;
  193.         }
  194.         if (!BuildCLIArgs(Args, DirLock, RootLock, NULL))
  195.             return FALSE;
  196.         SetWaitPointer(TRUE);
  197.         if (Item->emi_Mode == TOK_ARUN) {
  198.             strcpy(Buffer, Command.ri_Args);
  199.             if (AddArgs(Buffer, Args)) {
  200.                 Command.ri_Args = Buffer;
  201.                 ARun(&ParMConfig, &Command);
  202.             }
  203.         }
  204.         else {
  205.             strcpy(Buffer, Command.ri_Cmd);
  206.             if (AddArgs(Buffer, Args)) {
  207.                 Command.ri_Cmd = Buffer;
  208.                 Run(&ParMConfig, &Command, Item->emi_Mode);
  209.             }
  210.         }
  211.         SetWaitPointer(FALSE);
  212.         CurrentDir(BrowserDir);
  213.     }
  214.     return TRUE;
  215. }
  216.  
  217.  
  218. BOOL DoRun(struct ScrollEntry *S, BPTR RunDir, BPTR RootDir)
  219. {
  220.     struct Extended_WBStartup *EWBS;
  221.     struct DiskObject *DiskObject;
  222.     struct RunInfo Command;
  223.     char Cmd[256], Args[256], RunRequestTitle[40];
  224.     char *p, *ModeTitle;
  225.     short len;
  226.  
  227.     CurrentDir(RunDir);
  228.     strcpy(Cmd, S->se_FileInfo.fi_Name);
  229.     len = strlen(Cmd);
  230.     if (len>5) {
  231.         p = Cmd + len - 5;
  232.         if (!Strcmp(p, ".info"))
  233.             *p = '\0';        /* remove ".info" extension from filename */
  234.     }
  235.     if (DiskObject = GetDiskObject(Cmd)) {
  236.         FreeDiskObject(DiskObject);
  237.         if (EWBS = BuildWBStartup(S, Cmd, 0))
  238.             ASyncWBRun(&ParMConfig, EWBS, 0);
  239.     }
  240.     else {
  241.         if (BuildCLIArgs(Args, RunDir, RootDir, S)) {
  242.             if (strlen(S->se_FileInfo.fi_Name) + strlen(Args) + 2 > 255) {
  243.                 SimpleRequest(ReqTitle, "Command line too long.");
  244.                 CurrentDir(BrowserDir);
  245.                 return FALSE;
  246.             }
  247.             SPrintf(Cmd, "\"%s\"%s", S->se_FileInfo.fi_Name, Args);
  248.             Command.ri_Cmd = Cmd;
  249.             Command.ri_Args = NULL;
  250.             Command.ri_Window = ParMConfig.ShellWindow;
  251.             Command.ri_Stack = ParMConfig.DefaultStack;
  252.             Command.ri_Pri = 0;
  253.             if (Config.RunMode & RM_REQUEST) {
  254.                 switch(Config.RunMode & ~RM_REQUEST) {
  255.                 case RM_RUNBACK:
  256.                     ModeTitle = "RunBack";
  257.                     break;
  258.                 case RM_SHELL:
  259.                     ModeTitle = "Shell";
  260.                     break;
  261.                 }
  262.                 SPrintf(RunRequestTitle, "Run...  [%s mode]", ModeTitle);
  263.                 if (!GetString(Cmd, RunRequestTitle, NULL, 60, 255)) {
  264.                     CurrentDir(BrowserDir);
  265.                     return FALSE;
  266.                 }
  267.             }
  268.             switch(Config.RunMode & ~RM_REQUEST) {
  269.             case RM_RUNBACK:
  270.                 Run(&ParMConfig, &Command, TOK_RUN);
  271.                 break;
  272.             case RM_SHELL:
  273.                 Run(&ParMConfig, &Command, TOK_SHELL);
  274.                 break;
  275.             }
  276.         }        
  277.     }
  278.     CurrentDir(BrowserDir);
  279.     return TRUE;
  280. }
  281.  
  282.  
  283. void DoCommand(void)
  284. {
  285.     char Args[256];
  286.  
  287.     SetWaitPointer(TRUE);
  288.     if (CurrentWin->bw_Type != BW_MAIN)
  289.         CurrentDir(CurrentWin->bw_DirLock);
  290.     if (SelectNum > 0 && BuildCLIArgs(Args, CurrentWin->bw_DirLock, CurrentWin->bw_RootLock, NULL))
  291.         strcpy(ParMConfig.CommandBuffer, Args);
  292.     Command(&ParMConfig);
  293.     CurrentDir(BrowserDir);
  294.     SetWaitPointer(FALSE);
  295. }
  296.  
  297.  
  298.